namespace study202 {
    // partial将T中的所有属性设置为可选
    type Partital<T> = {
        [P in keyof T]?: T[P]
    }
    type Person = {
        name: string;
        age: number;
    }
    type p = Partital<Person>
    const p1: p = {

    }
    // Record 和Partial 很像，只是把? 替换成了 Readonlys
    type Readonly<T> = {
        readonly [P in keyof T]: T[P]
    }
    type R<T> = {
        readonly [P in keyof T]: T[P]
    }
    type Personb = {
        name: string;
        age: number;
        text: string;
    }
    type PersonbReadonly = R<Personb>


    // pick 从类型定义T的属性中，选取指定一组属性，返回一个新的类型定义。
    type Pick<T, K extends keyof T> = {
        [P in K]: T[P]
    }
    type Person1 = {
        name: string;
        age: number;
        text: string;
        address: string;
    }
    type Ex = "text" | "age"
    type A = Pick<Person1, Ex>

    // Record
    type Record<K extends keyof any, T> = {
        [P in K]: T;
    };
    //源码
    type Rec<K extends keyof any, T> = {
        [P in K]: T;
    }
    // K extends keyof any 范围如下
    type key = string | number | symbol
    //定义传入的值
    type Persona = {
        name: string,
        age: number,
        text: string
    }
    //定义可传入的健
    type K = "a" | "b" | "c"
    type NewRec = Rec<K, Persona>
    //ooo的key必须是a,b,c 而且不能缺少，值必须符合Persona的约束
    let ooo: NewRec = {
        "a": { name: 'xiaonan', age: 23, text: 'xxxx' },
        "b": { name: 'xiaonan', age: 23, text: 'xxxx' },
        "c": { name: 'xiaonan', age: 23, text: 'xxxx' }
    }
    console.log(ooo)


    // Omit
    // Omit < T, K >
    // T 是原始类型。
    // K 是要从 T 中排除的属性的联合类型。

    // 定义一个 User 类型
    interface User {
        id: number;
        name: string;
        email: string;
        password: string;
    }

    // 使用 Omit 创建一个新类型，不包含 password 属性
    type UserWithoutPassword = Omit<User, 'password'>;

    // 创建一个符合 UserWithoutPassword 类型的对象
    const user: UserWithoutPassword = {
        id: 1,
        name: 'Alice',
        email: 'alice@example.com',
    };

    console.log(user);

    // 你还可以将 Omit 与其他类型操作结合使用。
    // 例如，结合 Partial 类型来创建一个可选的用户类型，排除 id 属性。

    // 定义一个 User 类型
    interface User {
        id: number;
        name: string;
        email: string;
        password: string;
    }

    // 使用 Omit 和 Partial 创建一个新类型，排除 id 属性并使其他属性可选
    type PartialUserWithoutId = Partial<Omit<User, 'id'>>;

    // 创建一个符合 PartialUserWithoutId 类型的对象
    const updateUser: PartialUserWithoutId = {
        name: 'Bob',
        email: 'bob@example.com',
    };

    console.log(updateUser);

}
